const { v4: uuidv4 } = require('uuid');
const { db } = require('../config/database');
const { parseExcelFile, calculateFileHash } = require('../utils/fileUtils');

/**
 * 上传Excel文件
 */
const uploadFile = (req, res) => {
    try {
        const { submitter, changeDescription } = req.body;
        const file = req.file;
        
        if (!file) {
            return res.status(400).json({ error: '没有上传文件' });
        }

        const { headers, data } = parseExcelFile(file.path);
        const fileHash = calculateFileHash(file.path);
        const originalName = file.originalname;

        // 首先检查文件是否已存在
        db.get(
            'SELECT id FROM files WHERE original_name = ?',
            [originalName],
            (err, existingFile) => {
                if (err) {
                    console.error(err);
                    return res.status(500).json({ error: '数据库错误' });
                }

                let fileId;
                
                const processFileVersion = (fileId) => {
                    // 获取该文件的最新版本号
                    db.get(
                        'SELECT MAX(version) as max_version FROM file_versions WHERE file_id = ?',
                        [fileId],
                        (err, row) => {
                            if (err) {
                                console.error(err);
                                return res.status(500).json({ error: '获取版本信息失败' });
                            }

                            const version = (row.max_version || 0) + 1;
                            const versionId = uuidv4();

                            // 插入新版本记录
                            db.run(
                                `INSERT INTO file_versions (id, file_id, version, filename, file_path, submitter, change_description, file_size)
                                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
                                [versionId, fileId, version, file.filename, file.path, submitter, changeDescription, file.size],
                                function(err) {
                                    if (err) {
                                        console.error(err);
                                        return res.status(500).json({ error: '保存版本信息失败' });
                                    }

                                    // 插入表格数据
                                    const stmt = db.prepare(`
                                        INSERT INTO table_data (id, version_id, row_index, column_name, cell_value, cell_type)
                                        VALUES (?, ?, ?, ?, ?, ?)
                                    `);

                                    data.forEach((row, rowIndex) => {
                                        headers.forEach(header => {
                                            const cellId = uuidv4();
                                            const cellValue = row[header];
                                            const cellType = typeof cellValue === 'number' ? 'number' : 'text';
                                            
                                            stmt.run([cellId, versionId, rowIndex, header, cellValue, cellType]);
                                        });
                                    });

                                    stmt.finalize();

                                    // 更新文件的最后修改时间
                                    db.run(
                                        'UPDATE files SET updated_at = CURRENT_TIMESTAMP WHERE id = ?',
                                        [fileId]
                                    );

                                    res.json({
                                        success: true,
                                        fileId,
                                        versionId,
                                        version,
                                        headers,
                                        dataCount: data.length,
                                        message: `文件 "${originalName}" 的第 ${version} 版本上传成功`
                                    });
                                }
                            );
                        }
                    );
                };

                if (existingFile) {
                    // 文件已存在，添加新版本
                    fileId = existingFile.id;
                    processFileVersion(fileId);
                } else {
                    // 新文件，创建文件记录
                    fileId = uuidv4();
                    db.run(
                        `INSERT INTO files (id, original_name, file_hash, created_by)
                         VALUES (?, ?, ?, ?)`,
                        [fileId, originalName, fileHash, submitter],
                        function(err) {
                            if (err) {
                                console.error(err);
                                return res.status(500).json({ error: '创建文件记录失败' });
                            }
                            processFileVersion(fileId);
                        }
                    );
                }
            }
        );
    } catch (error) {
        console.error('上传错误:', error);
        res.status(500).json({ error: '文件处理失败' });
    }
};

/**
 * 获取所有文件列表
 */
const getFiles = (req, res) => {
    const query = `
        SELECT 
            f.id,
            f.original_name,
            f.created_by,
            f.created_at,
            f.updated_at,
            COUNT(fv.id) as version_count,
            MAX(fv.version) as latest_version,
            MAX(fv.created_at) as last_modified
        FROM files f
        LEFT JOIN file_versions fv ON f.id = fv.file_id
        GROUP BY f.id, f.original_name, f.created_by, f.created_at, f.updated_at
        ORDER BY f.updated_at DESC
    `;
    
    db.all(query, (err, rows) => {
        if (err) {
            console.error(err);
            return res.status(500).json({ error: '获取文件列表失败' });
        }
        res.json(rows);
    });
};

/**
 * 获取特定文件的版本列表
 */
const getFileVersions = (req, res) => {
    const { fileId } = req.params;
    
    db.all(
        `SELECT fv.*, f.original_name
         FROM file_versions fv
         JOIN files f ON fv.file_id = f.id
         WHERE fv.file_id = ?
         ORDER BY fv.version DESC`,
        [fileId],
        (err, rows) => {
            if (err) {
                console.error(err);
                return res.status(500).json({ error: '获取版本列表失败' });
            }
            res.json(rows);
        }
    );
};

/**
 * 删除文件及其所有版本和相关数据
 */
const deleteFile = (req, res) => {
    const { fileId } = req.params;
    
    // 开始事务
    db.serialize(() => {
        db.run('BEGIN TRANSACTION');
        
        // 首先检查文件是否存在
        db.get(
            'SELECT id, original_name FROM files WHERE id = ?',
            [fileId],
            (err, file) => {
                if (err) {
                    console.error(err);
                    db.run('ROLLBACK');
                    return res.status(500).json({ error: '查询文件失败' });
                }
                
                if (!file) {
                    db.run('ROLLBACK');
                    return res.status(404).json({ error: '文件不存在' });
                }
                
                // 获取所有版本ID用于删除相关数据
                db.all(
                    'SELECT id FROM file_versions WHERE file_id = ?',
                    [fileId],
                    (err, versions) => {
                        if (err) {
                            console.error(err);
                            db.run('ROLLBACK');
                            return res.status(500).json({ error: '获取版本信息失败' });
                        }
                        
                        const versionIds = versions.map(v => v.id);
                        
                        // 删除相关数据的函数
                        const deleteRelatedData = (callback) => {
                            if (versionIds.length === 0) {
                                return callback();
                            }
                            
                            const placeholders = versionIds.map(() => '?').join(',');
                            
                            // 删除表格数据
                            db.run(
                                `DELETE FROM table_data WHERE version_id IN (${placeholders})`,
                                versionIds,
                                (err) => {
                                    if (err) {
                                        console.error('删除表格数据失败:', err);
                                        return callback(err);
                                    }
                                    
                                    // 删除批注
                                    db.run(
                                        `DELETE FROM annotations WHERE version_id IN (${placeholders})`,
                                        versionIds,
                                        (err) => {
                                            if (err) {
                                                console.error('删除批注失败:', err);
                                                return callback(err);
                                            }
                                            
                                            // 删除自定义列
                                            db.run(
                                                `DELETE FROM custom_columns WHERE version_id IN (${placeholders})`,
                                                versionIds,
                                                (err) => {
                                                    if (err) {
                                                        console.error('删除自定义列失败:', err);
                                                        return callback(err);
                                                    }
                                                    callback();
                                                }
                                            );
                                        }
                                    );
                                }
                            );
                        };
                        
                        // 执行删除操作
                        deleteRelatedData((err) => {
                            if (err) {
                                db.run('ROLLBACK');
                                return res.status(500).json({ error: '删除相关数据失败' });
                            }
                            
                            // 删除文件版本
                            db.run(
                                'DELETE FROM file_versions WHERE file_id = ?',
                                [fileId],
                                (err) => {
                                    if (err) {
                                        console.error('删除文件版本失败:', err);
                                        db.run('ROLLBACK');
                                        return res.status(500).json({ error: '删除文件版本失败' });
                                    }
                                    
                                    // 删除文件记录
                                    db.run(
                                        'DELETE FROM files WHERE id = ?',
                                        [fileId],
                                        (err) => {
                                            if (err) {
                                                console.error('删除文件记录失败:', err);
                                                db.run('ROLLBACK');
                                                return res.status(500).json({ error: '删除文件记录失败' });
                                            }
                                            
                                            // 提交事务
                                            db.run('COMMIT', (err) => {
                                                if (err) {
                                                    console.error('提交事务失败:', err);
                                                    db.run('ROLLBACK');
                                                    return res.status(500).json({ error: '删除操作失败' });
                                                }
                                                
                                                res.json({
                                                    success: true,
                                                    message: `文件 "${file.original_name}" 及其所有版本已成功删除`
                                                });
                                            });
                                        }
                                    );
                                }
                            );
                        });
                    }
                );
            }
        );
    });
};

module.exports = {
    uploadFile,
    getFiles,
    getFileVersions,
    deleteFile
};